#include <iostream>
#include <sstream>
#include <vector>
#include <string>

// 定义树节点结构
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// 辅助函数：从前序遍历序列构建二叉树
TreeNode *buildTree(std::vector<std::string> &nodes, int &index)
{
    if (index >= nodes.size() || nodes[index] == "-")
    {
        index++;
        return nullptr;
    }//不存在时
    TreeNode *root = new TreeNode(std::stoi(nodes[index])); //root
    index++;
    root->left = buildTree(nodes, index);//left
    root->right = buildTree(nodes, index);//right
    return root;
}

// 辅助函数：前序遍历二叉树
void preorderTraversal(TreeNode *root)
{
    if (root == nullptr)
    {
        std::cout << "- ";
        return;
    }
    std::cout << root->val << " ";
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

// Solution 类
class Solution
{
public:
    TreeNode *target1 = nullptr;
    TreeNode *target2 = nullptr;
    TreeNode *preroot = nullptr;

    void recoverTree(TreeNode *root)
    {
        dfs(root);
        std::swap(target1->val, target2->val);
    }

    void dfs(TreeNode *root)//中序打印（顺序） 找到错误数字
    {
        if (root == nullptr)
        {
            return;
        }
        dfs(root->left);
        if (preroot != nullptr)
        {
            if (preroot->val >= root->val)
            {
                if (target1 == nullptr)
                {
                    target1 = preroot;
                    target2 = root;
                }
                else
                {
                    target2 = root;
                    return;
                }
            }
        }
        preroot = root;
        dfs(root->right);
    }
};

int main()
{
    std::string input;
    std::getline(std::cin, input);
    std::istringstream iss(input);
    std::vector<std::string> nodes;
    std::string token;

    while (iss >> token)
    {
        nodes.push_back(token);
    }

    int index = 0;
    TreeNode *root = buildTree(nodes, index);

    Solution sol;
    sol.recoverTree(root);

    preorderTraversal(root);
    std::cout << std::endl;

    return 0;
}
// // 从字符串中解析数字
// void parseNumbers(const string &input, vector<double> &nums)
// {
//     double numbers;
//     stringstream ss(input);
//     string token;
//     while (getline(ss, token, ','))
//     {
//         numbers = stod(token);
//         nums.push_back(numbers);
//     }
// }
// int main()
// {
//     //     int N;
//     double num;
//     // cin >> N;
//     // cin.ignore(); // 忽略第一个输入后的换行符
//                   // for (int i = 0; i < N; i++)
//                   // {
//     vector<double> arr;
//     string line;
//     getline(cin, line);
//     stringstream ss(line);
//     while (ss >> num) // 回车后 stringstream 对象 ss 已经读取完了整行输入，并且没有更多的数据可以读取，它会返回 false，从而终止 while 循环。
//     {
//         arr.push_back(num);
//     }
//     heapSort(arr);
//     for (auto it : arr)
//     {
//         cout << it << " ";
//     }
//     cout << endl;
// }


// for (int i = 0; i < N; i++)
// {
//     vector<double> arr;
//     string line;
//     getline(cin, line); // 读取整行输入
//     parseNumbers(line, arr);
//     bubblesort(arr);
// }
